{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "PaddlePaddle 1.8.0 (Python 3.5)",
      "language": "python",
      "name": "py35-paddle1.2.0"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "百度顶会复现营——车牌识别.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sunyingjian/Baidu-AI--course/blob/master/%E7%99%BE%E5%BA%A6%E9%A1%B6%E4%BC%9A%E5%A4%8D%E7%8E%B0%E8%90%A5%E2%80%94%E2%80%94%E8%BD%A6%E7%89%8C%E8%AF%86%E5%88%AB.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "-Z-_7bdu67V7",
        "colab_type": "text"
      },
      "source": [
        "# **作业描述：**\n",
        "\n",
        "### **✓代码跑通**\n",
        "\n",
        "### 请大家根据课上所学内容，在 MyDNN类中补全代码，构造DNN网络，保证程序跑通。\n",
        "\n",
        "### **✓调优**\n",
        "\n",
        "### 思考并动手进行调优，以在验证集上的准确率为评价指标，验证集上准确率越高，得分越高！"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "n_PdfNfC67V8",
        "colab_type": "text"
      },
      "source": [
        "# **任务描述：**\n",
        "\n",
        "### 本次实践是一个多分类任务，需要将照片中的每个字符分别进行识别，完成**车牌的识别**\n",
        "\n",
        "### **实践平台：百度AI实训平台-AI Studio、PaddlePaddle1.8.0 动态图**\n",
        "\n",
        "![](https://ai-studio-static-online.cdn.bcebos.com/4937002eccc64274b9877ad4c961fe32fff0a6b3e32e468390ba68d29664c6c4)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "3DmT9fLD67V9",
        "colab_type": "text"
      },
      "source": [
        "# 深度神经网络(DNN)\n",
        "\n",
        "### **深度神经网络（Deep Neural Networks，简称DNN）是深度学习的基础，其结构为input、hidden（可有多层）、output，每层均为全连接。**\n",
        "![](https://ai-studio-static-online.cdn.bcebos.com/c60fc28848cf469fa3a7824aa637a03f3b2b213ce7b84659919cb24b4430bffb)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "xlrzPUeU67V-",
        "colab_type": "text"
      },
      "source": [
        "# 数据集介绍\n",
        "\n",
        "* **数据集文件名为characterData.zip，其中有65个文件夹**\n",
        "\n",
        "* **包含0-9，A-Z，以及各省简称**\n",
        "\n",
        "* **图片为1*20*20的灰度图像**\n",
        "\n",
        "* **本次实验中，取其中的10%作为测试集，90%作为训练集**\n",
        "\n",
        "![](https://ai-studio-static-online.cdn.bcebos.com/98752767a5da477eb5a2927d491e890cf2c82725afbd49b5826fab44e514218a)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iE2xzH5p67V-",
        "colab_type": "code",
        "colab": {},
        "outputId": "f8fc0779-ee30-4a22-93df-3d16e848401c"
      },
      "source": [
        "# 查看当前挂载的数据集目录, 该目录下的变更重启环境后会自动还原\n",
        "# View dataset directory. This directory will be recovered automatically after resetting environment. \n",
        "!ls /home/aistudio/data"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "data23617  dataset  readme.json\r\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TdaL8G3y67WE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#导入需要的包\n",
        "import os\n",
        "import zipfile\n",
        "import random\n",
        "import json\n",
        "import cv2\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import paddle\n",
        "import paddle.fluid as fluid\n",
        "from paddle.fluid.dygraph import Linear,Conv2D,Pool2D,Dropout,BatchNorm\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "Mo9CD_xb67WH",
        "colab_type": "text"
      },
      "source": [
        "# 1、数据准备"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__6zDqMA67WH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "'''\n",
        "参数配置\n",
        "'''\n",
        "train_parameters = {\n",
        "    \"input_size\": [1, 20, 20],                           #输入图片的shape\n",
        "    \"class_dim\": -1,                                     #分类数\n",
        "    \"src_path\":\"data/data23617/characterData.zip\",       #原始数据集路径\n",
        "    \"target_path\":\"/home/aistudio/data/dataset\",        #要解压的路径 \n",
        "    \"train_list_path\": \"./train_data.txt\",              #train_data.txt路径\n",
        "    \"eval_list_path\": \"./val_data.txt\",                  #eval_data.txt路径\n",
        "    \"label_dict\":{},                                    #标签字典\n",
        "    \"readme_path\": \"/home/aistudio/data/readme.json\",   #readme.json路径\n",
        "    \"num_epochs\": 4,                                    #训练轮数\n",
        "    \"train_batch_size\": 256,                             #批次的大小\n",
        "    \"learning_strategy\": {                              #优化函数相关的配置\n",
        "        \"lr\": 0.0001                                     #超参数学习率\n",
        "    } \n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1XCsmPGV67WL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def unzip_data(src_path,target_path):\n",
        "    '''\n",
        "    解压原始数据集，将src_path路径下的zip包解压至data/dataset目录下\n",
        "    '''\n",
        "    if(not os.path.isdir(target_path)):    \n",
        "        z = zipfile.ZipFile(src_path, 'r')\n",
        "        z.extractall(path=target_path)\n",
        "        z.close()\n",
        "    else:\n",
        "        print(\"文件已解压\")\n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iNPhNEuQ67WO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def get_data_list(target_path,train_list_path,eval_list_path):\n",
        "    '''\n",
        "    生成数据列表\n",
        "    '''\n",
        "    #存放所有类别的信息\n",
        "    class_detail = []\n",
        "    #获取所有类别保存的文件夹名称\n",
        "    data_list_path=target_path\n",
        "    class_dirs = os.listdir(data_list_path)\n",
        "    if '__MACOSX' in class_dirs:\n",
        "        class_dirs.remove('__MACOSX')\n",
        "    # #总的图像数量\n",
        "    all_class_images = 0\n",
        "    # #存放类别标签\n",
        "    class_label=0\n",
        "    # #存放类别数目\n",
        "    class_dim = 0\n",
        "    # #存储要写进eval.txt和train.txt中的内容\n",
        "    trainer_list=[]\n",
        "    eval_list=[]\n",
        "    #读取每个类别\n",
        "    for class_dir in class_dirs:\n",
        "        if class_dir != \".DS_Store\":\n",
        "            class_dim += 1\n",
        "            #每个类别的信息\n",
        "            class_detail_list = {}\n",
        "            eval_sum = 0\n",
        "            trainer_sum = 0\n",
        "            #统计每个类别有多少张图片\n",
        "            class_sum = 0\n",
        "            #获取类别路径 \n",
        "            path = os.path.join(data_list_path,class_dir)\n",
        "            # print(path)\n",
        "            # 获取所有图片\n",
        "            img_paths = os.listdir(path)\n",
        "            for img_path in img_paths:                                  # 遍历文件夹下的每个图片\n",
        "                if img_path =='.DS_Store':\n",
        "                    continue\n",
        "                name_path = os.path.join(path,img_path)                       # 每张图片的路径\n",
        "                if class_sum % 10 == 0:                                 # 每10张图片取一个做验证数据\n",
        "                    eval_sum += 1                                       # eval_sum为测试数据的数目\n",
        "                    eval_list.append(name_path + \"\\t%d\" % class_label + \"\\n\")\n",
        "                else:\n",
        "                    trainer_sum += 1 \n",
        "                    trainer_list.append(name_path + \"\\t%d\" % class_label + \"\\n\")#trainer_sum测试数据的数目\n",
        "                class_sum += 1                                          #每类图片的数目\n",
        "                all_class_images += 1                                   #所有类图片的数目\n",
        "            \n",
        "            # 说明的json文件的class_detail数据\n",
        "            class_detail_list['class_name'] = class_dir             #类别名称\n",
        "            class_detail_list['class_label'] = class_label          #类别标签\n",
        "            class_detail_list['class_eval_images'] = eval_sum       #该类数据的测试集数目\n",
        "            class_detail_list['class_trainer_images'] = trainer_sum #该类数据的训练集数目\n",
        "            class_detail.append(class_detail_list)  \n",
        "            #初始化标签列表\n",
        "            train_parameters['label_dict'][str(class_label)] = class_dir\n",
        "            class_label += 1\n",
        "            \n",
        "    #初始化分类数\n",
        "    train_parameters['class_dim'] = class_dim\n",
        "    print(train_parameters)\n",
        "    #乱序  \n",
        "    random.shuffle(eval_list)\n",
        "    with open(eval_list_path, 'a') as f:\n",
        "        for eval_image in eval_list:\n",
        "            f.write(eval_image) \n",
        "    #乱序        \n",
        "    random.shuffle(trainer_list) \n",
        "    with open(train_list_path, 'a') as f2:\n",
        "        for train_image in trainer_list:\n",
        "            f2.write(train_image) \n",
        "\n",
        "    # 说明的json文件信息\n",
        "    readjson = {}\n",
        "    readjson['all_class_name'] = data_list_path                  #文件父目录\n",
        "    readjson['all_class_images'] = all_class_images\n",
        "    readjson['class_detail'] = class_detail\n",
        "    jsons = json.dumps(readjson, sort_keys=True, indent=4, separators=(',', ': '))\n",
        "    with open(train_parameters['readme_path'],'w') as f:\n",
        "        f.write(jsons)\n",
        "    print ('生成数据列表完成！')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gA8RAJ6l67WQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def data_reader(file_list):\n",
        "    '''\n",
        "    自定义data_reader\n",
        "    '''\n",
        "    def reader():\n",
        "        with open(file_list, 'r') as f:\n",
        "            lines = [line.strip() for line in f]\n",
        "            for line in lines:\n",
        "                img_path, lab = line.strip().split('\\t')\n",
        "                img = cv2.imread(img_path)\n",
        "                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "                img = np.array(img).astype('float32')\n",
        "                img = img/255.0\n",
        "                yield img, int(lab) \n",
        "    return reader"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1sPqcKMB67WV",
        "colab_type": "code",
        "colab": {},
        "outputId": "cc4fe68b-38c0-4b3b-bddc-a52a84df8fa9"
      },
      "source": [
        "'''\n",
        "参数初始化\n",
        "'''\n",
        "src_path=train_parameters['src_path']\n",
        "target_path=train_parameters['target_path']\n",
        "train_list_path=train_parameters['train_list_path']\n",
        "eval_list_path=train_parameters['eval_list_path']\n",
        "batch_size=train_parameters['train_batch_size']\n",
        "'''\n",
        "解压原始数据到指定路径\n",
        "'''\n",
        "unzip_data(src_path,target_path)\n",
        "\n",
        "#每次生成数据列表前，首先清空train.txt和eval.txt\n",
        "with open(train_list_path, 'w') as f: \n",
        "    f.seek(0)\n",
        "    f.truncate() \n",
        "with open(eval_list_path, 'w') as f: \n",
        "    f.seek(0)\n",
        "    f.truncate() \n",
        "    \n",
        "#生成数据列表   \n",
        "get_data_list(target_path,train_list_path,eval_list_path)\n",
        "\n",
        "'''\n",
        "构造数据提供器\n",
        "'''\n",
        "train_reader = paddle.batch(data_reader(train_list_path),\n",
        "                            batch_size=batch_size,\n",
        "                            drop_last=True)\n",
        "eval_reader = paddle.batch(data_reader(eval_list_path),\n",
        "                            batch_size=batch_size,\n",
        "                            drop_last=True)\n",
        "                            "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "文件已解压\n",
            "{'input_size': [1, 20, 20], 'class_dim': 65, 'src_path': 'data/data23617/characterData.zip', 'target_path': '/home/aistudio/data/dataset', 'train_list_path': './train_data.txt', 'eval_list_path': './val_data.txt', 'label_dict': {'0': 'gan1', '1': 'gui1', '2': 'gan', '3': '0', '4': 'ning', '5': 'sx', '6': '7', '7': 'A', '8': 'N', '9': 'K', '10': 'yue', '11': 'S', '12': 'ji', '13': 'J', '14': 'B', '15': 'R', '16': 'C', '17': 'su', '18': '5', '19': '2', '20': 'X', '21': 'U', '22': 'M', '23': 'jing', '24': 'gui', '25': 'yun', '26': 'min', '27': 'zhe', '28': 'Z', '29': '9', '30': 'yu', '31': 'qiong', '32': 'lu', '33': 'T', '34': 'xiang', '35': 'V', '36': 'W', '37': 'shan', '38': '3', '39': 'jl', '40': 'qing', '41': 'liao', '42': '6', '43': 'Q', '44': 'G', '45': 'H', '46': 'E', '47': 'P', '48': 'F', '49': '1', '50': 'D', '51': 'e1', '52': 'jin', '53': 'yu1', '54': 'xin', '55': 'wan', '56': 'cuan', '57': 'Y', '58': '4', '59': 'zang', '60': '8', '61': 'L', '62': 'hu', '63': 'meng', '64': 'hei'}, 'readme_path': '/home/aistudio/data/readme.json', 'num_epochs': 4, 'train_batch_size': 256, 'learning_strategy': {'lr': 0.0001}}\n",
            "生成数据列表完成！\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pJ5wYNEi67WY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "Batch=0\n",
        "Batchs=[]\n",
        "all_train_accs=[]\n",
        "def draw_train_acc(Batchs, train_accs):\n",
        "    title=\"training accs\"\n",
        "    plt.title(title, fontsize=24)\n",
        "    plt.xlabel(\"batch\", fontsize=14)\n",
        "    plt.ylabel(\"acc\", fontsize=14)\n",
        "    plt.plot(Batchs, train_accs, color='green', label='training accs')\n",
        "    plt.legend()\n",
        "    plt.grid()\n",
        "    plt.show()\n",
        "\n",
        "all_train_loss=[]\n",
        "def draw_train_loss(Batchs, train_loss):\n",
        "    title=\"training loss\"\n",
        "    plt.title(title, fontsize=24)\n",
        "    plt.xlabel(\"batch\", fontsize=14)\n",
        "    plt.ylabel(\"loss\", fontsize=14)\n",
        "    plt.plot(Batchs, train_loss, color='red', label='training loss')\n",
        "    plt.legend()\n",
        "    plt.grid()\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "pnMnLxtN67Wa",
        "colab_type": "text"
      },
      "source": [
        "# 2、定义模型"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "b_uBC9l067Wb",
        "colab_type": "text"
      },
      "source": [
        "### ###在以下cell中完成cnn网络的定义###"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tZCcfCjf67Wb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#定义CNN网络\n",
        "class MyCNN(fluid.dygraph.Layer):\n",
        "    \n",
        "    def __init__(self):\n",
        "        super(MyCNN,self).__init__()\n",
        "        self.CNN1 = Conv2D(num_channels=1,stride=1,filter_size = 3,num_filters = 32,act = 'relu')\n",
        "        self.Pool1 = Pool2D(pool_size=2,pool_stride=1,pool_type = 'max')\n",
        "        self.DROP1 = Dropout(0.2)\n",
        "        self.Batch1 = BatchNorm(32)\n",
        "        self.CNN2 = Conv2D(num_channels=32,stride = 1,filter_size = 3,num_filters = 128,act = 'relu')\n",
        "        self.Pool2 = Pool2D(pool_size=2,pool_stride=1,pool_type = 'max')\n",
        "        self.DROP2 = Dropout(0.3)\n",
        "        self.Batch2 = BatchNorm(128)\n",
        "        self.Fc1 = Linear(input_dim = 128*14*14,output_dim= 256 ,act='relu')\n",
        "        self.Fc2 = Linear(input_dim= 256,output_dim= 65,act=\"softmax\")\n",
        "    def forward(self,input):        # forward 定义执行实际运行时网络的执行逻辑\n",
        "        x = self.CNN1(input)\n",
        "        x = self.Pool1(x)\n",
        "        x = self.DROP1(x)\n",
        "        x = self.Batch1(x)\n",
        "        x = self.CNN2(x)\n",
        "        x = self.Pool2(x)\n",
        "        x = self.DROP2(x)\n",
        "        x = self.Batch2(x)\n",
        "        x = fluid.layers.reshape(x,[x.shape[0],-1])\n",
        "        x = self.Fc1(x)\n",
        "        x = self.Fc2(x)\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "eWAj2wNU67Wd",
        "colab_type": "text"
      },
      "source": [
        "# 3、训练模型"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dI3mpDZr67We",
        "colab_type": "code",
        "colab": {},
        "outputId": "c0d59b35-a84c-4ba5-b12c-b87a2c9006ed"
      },
      "source": [
        "with fluid.dygraph.guard():\n",
        "    model=MyCNN() #模型实例化\n",
        "    model.train() #训练模式\n",
        "    opt=fluid.optimizer.AdamOptimizer(learning_rate=train_parameters['learning_strategy']['lr'], parameter_list=model.parameters())#优化器选用adam随机梯度下降，学习率为0.001.\n",
        "    epochs_num=train_parameters['num_epochs'] #迭代次数\n",
        "    \n",
        "    for pass_num in range(epochs_num):\n",
        "        for batch_id,data in enumerate(train_reader()):\n",
        "            images=np.array([x[0].reshape(1,20,20) for x in data],np.float32)\n",
        "            labels = np.array([x[1] for x in data]).astype('int64')\n",
        "            labels = labels[:, np.newaxis]\n",
        "            image=fluid.dygraph.to_variable(images)\n",
        "            label=fluid.dygraph.to_variable(labels)\n",
        "\n",
        "            predict=model(image) #数据传入model\n",
        "            \n",
        "            loss=fluid.layers.cross_entropy(predict,label)\n",
        "            avg_loss=fluid.layers.mean(loss)#获取loss值\n",
        "            \n",
        "            acc=fluid.layers.accuracy(predict,label)#计算精度\n",
        "            \n",
        "            if batch_id!=0 and batch_id%50==0:\n",
        "                Batch = Batch+100\n",
        "                Batchs.append(Batch)\n",
        "                all_train_loss.append(avg_loss.numpy()[0])\n",
        "                all_train_accs.append(acc.numpy()[0])\n",
        "                \n",
        "                print(\"train_pass:{},batch_id:{},train_loss:{},train_acc:{}\".format(pass_num,batch_id,avg_loss.numpy(),acc.numpy()))\n",
        "            \n",
        "            avg_loss.backward()       \n",
        "            opt.minimize(avg_loss)    #优化器对象的minimize方法对参数进行更新 \n",
        "            model.clear_gradients()   #model.clear_gradients()来重置梯度\n",
        "    fluid.save_dygraph(model.state_dict(),'MyCNN')#保存模型\n",
        "\n",
        "draw_train_acc(Batchs,all_train_accs)\n",
        "draw_train_loss(Batchs,all_train_loss)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "train_pass:0,batch_id:50,train_loss:[0.34983468],train_acc:[0.9140625]\n",
            "train_pass:1,batch_id:50,train_loss:[0.15753123],train_acc:[0.96484375]\n",
            "train_pass:2,batch_id:50,train_loss:[0.0904939],train_acc:[0.98046875]\n",
            "train_pass:3,batch_id:50,train_loss:[0.06739254],train_acc:[0.98046875]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "9Jjn5Kvx67Wh",
        "colab_type": "text"
      },
      "source": [
        "# 4、模型评估"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FocAOjo367Wi",
        "colab_type": "code",
        "colab": {},
        "outputId": "43665b25-f63d-4033-ba7a-a19b4fae1a74"
      },
      "source": [
        "\n",
        "#模型评估\n",
        "with fluid.dygraph.guard():\n",
        "    accs = []\n",
        "    model_dict, _ = fluid.load_dygraph('MyCNN')\n",
        "    model = MyCNN()\n",
        "    model.load_dict(model_dict) #加载模型参数\n",
        "    model.eval() #训练模式\n",
        "    for batch_id,data in enumerate(eval_reader()):#测试集\n",
        "        images=np.array([x[0].reshape(1,20,20) for x in data],np.float32)\n",
        "        labels = np.array([x[1] for x in data]).astype('int64')\n",
        "        labels = labels[:, np.newaxis]\n",
        "        image=fluid.dygraph.to_variable(images)\n",
        "        label=fluid.dygraph.to_variable(labels)       \n",
        "        predict=model(image)       \n",
        "        acc=fluid.layers.accuracy(predict,label)\n",
        "        accs.append(acc.numpy()[0])\n",
        "        avg_acc = np.mean(accs)\n",
        "    print(avg_acc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.96744794\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "VEE7VR7o67Wm",
        "colab_type": "text"
      },
      "source": [
        "# 5、使用模型"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "XlNiEfTm67Wm",
        "colab_type": "text"
      },
      "source": [
        "### **5.1对车牌图像进行预处理**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lPtZ7Nvv67Wn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 对车牌图片进行处理，分割出车牌中的每一个字符并保存\n",
        "license_plate = cv2.imread('work/车牌.png')\n",
        "gray_plate = cv2.cvtColor(license_plate, cv2.COLOR_RGB2GRAY) \n",
        "ret, binary_plate = cv2.threshold(gray_plate, 175, 255, cv2.THRESH_BINARY) #ret：阈值，binary_plate：根据阈值处理后的图像数据\n",
        "# 按列统计像素分布\n",
        "result = []\n",
        "for col in range(binary_plate.shape[1]):\n",
        "    result.append(0)\n",
        "    for row in range(binary_plate.shape[0]):\n",
        "        result[col] = result[col] + binary_plate[row][col]/255\n",
        "# print(result)\n",
        "#记录车牌中字符的位置\n",
        "character_dict = {}\n",
        "num = 0\n",
        "i = 0\n",
        "while i < len(result):\n",
        "    if result[i] == 0:\n",
        "        i += 1\n",
        "    else:\n",
        "        index = i + 1\n",
        "        while result[index] != 0:\n",
        "            index += 1\n",
        "        character_dict[num] = [i, index-1]\n",
        "        num += 1\n",
        "        i = index\n",
        "# print(character_dict)        \n",
        "#将每个字符填充，并存储\n",
        "characters = []\n",
        "for i in range(8):\n",
        "    if i==2:\n",
        "        continue\n",
        "    padding = (170 - (character_dict[i][1] - character_dict[i][0])) / 2\n",
        "    #将单个字符图像填充为170*170\n",
        "    ndarray = np.pad(binary_plate[:,character_dict[i][0]:character_dict[i][1]], ((0,0), (int(padding), int(padding))), 'constant', constant_values=(0,0))\n",
        "    ndarray = cv2.resize(ndarray, (20,20))\n",
        "    cv2.imwrite('work/' + str(i) + '.png', ndarray)\n",
        "    characters.append(ndarray)\n",
        "    \n",
        "def load_image(path):\n",
        "    img = paddle.dataset.image.load_image(file=path, is_color=False)\n",
        "    img = img.astype('float32')\n",
        "    img = img[np.newaxis, ] / 255.0\n",
        "    return img"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "GcXsxTCV67Wp",
        "colab_type": "text"
      },
      "source": [
        "### **5.2 对标签进行转换**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d1NeeryH67Wq",
        "colab_type": "code",
        "colab": {},
        "outputId": "473eb06f-be13-4575-9920-e0ecae8309df"
      },
      "source": [
        "#将标签进行转换\n",
        "print('Label:',train_parameters['label_dict'])\n",
        "match = {'A':'A','B':'B','C':'C','D':'D','E':'E','F':'F','G':'G','H':'H','I':'I','J':'J','K':'K','L':'L','M':'M','N':'N',\n",
        "        'O':'O','P':'P','Q':'Q','R':'R','S':'S','T':'T','U':'U','V':'V','W':'W','X':'X','Y':'Y','Z':'Z',\n",
        "        'yun':'云','cuan':'川','hei':'黑','zhe':'浙','ning':'宁','jin':'津','gan':'赣','hu':'沪','liao':'辽','jl':'吉','qing':'青','zang':'藏',\n",
        "        'e1':'鄂','meng':'蒙','gan1':'甘','qiong':'琼','shan':'陕','min':'闽','su':'苏','xin':'新','wan':'皖','jing':'京','xiang':'湘','gui':'贵',\n",
        "        'yu1':'渝','yu':'豫','ji':'冀','yue':'粤','gui1':'桂','sx':'晋','lu':'鲁',\n",
        "        '0':'0','1':'1','2':'2','3':'3','4':'4','5':'5','6':'6','7':'7','8':'8','9':'9'}\n",
        "L = 0\n",
        "LABEL ={}\n",
        "for V in train_parameters['label_dict'].values():\n",
        "    LABEL[str(L)] = match[V]\n",
        "    L += 1\n",
        "print(LABEL)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Label: {'0': 'gan1', '1': 'gui1', '2': 'gan', '3': '0', '4': 'ning', '5': 'sx', '6': '7', '7': 'A', '8': 'N', '9': 'K', '10': 'yue', '11': 'S', '12': 'ji', '13': 'J', '14': 'B', '15': 'R', '16': 'C', '17': 'su', '18': '5', '19': '2', '20': 'X', '21': 'U', '22': 'M', '23': 'jing', '24': 'gui', '25': 'yun', '26': 'min', '27': 'zhe', '28': 'Z', '29': '9', '30': 'yu', '31': 'qiong', '32': 'lu', '33': 'T', '34': 'xiang', '35': 'V', '36': 'W', '37': 'shan', '38': '3', '39': 'jl', '40': 'qing', '41': 'liao', '42': '6', '43': 'Q', '44': 'G', '45': 'H', '46': 'E', '47': 'P', '48': 'F', '49': '1', '50': 'D', '51': 'e1', '52': 'jin', '53': 'yu1', '54': 'xin', '55': 'wan', '56': 'cuan', '57': 'Y', '58': '4', '59': 'zang', '60': '8', '61': 'L', '62': 'hu', '63': 'meng', '64': 'hei'}\n",
            "{'0': '甘', '1': '桂', '2': '赣', '3': '0', '4': '宁', '5': '晋', '6': '7', '7': 'A', '8': 'N', '9': 'K', '10': '粤', '11': 'S', '12': '冀', '13': 'J', '14': 'B', '15': 'R', '16': 'C', '17': '苏', '18': '5', '19': '2', '20': 'X', '21': 'U', '22': 'M', '23': '京', '24': '贵', '25': '云', '26': '闽', '27': '浙', '28': 'Z', '29': '9', '30': '豫', '31': '琼', '32': '鲁', '33': 'T', '34': '湘', '35': 'V', '36': 'W', '37': '陕', '38': '3', '39': '吉', '40': '青', '41': '辽', '42': '6', '43': 'Q', '44': 'G', '45': 'H', '46': 'E', '47': 'P', '48': 'F', '49': '1', '50': 'D', '51': '鄂', '52': '津', '53': '渝', '54': '新', '55': '皖', '56': '川', '57': 'Y', '58': '4', '59': '藏', '60': '8', '61': 'L', '62': '沪', '63': '蒙', '64': '黑'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "Cfhzxou667Ws",
        "colab_type": "text"
      },
      "source": [
        "### **5.3 使用模型进行预测**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5oU3IinN67Wt",
        "colab_type": "code",
        "colab": {},
        "outputId": "03b819ae-244a-4329-e6ef-2c4be3b9cd55"
      },
      "source": [
        "#构建预测动态图过程\n",
        "with fluid.dygraph.guard():\n",
        "    model=MyCNN()#模型实例化\n",
        "    model_dict,_=fluid.load_dygraph('MyCNN')\n",
        "    model.load_dict(model_dict)#加载模型参数\n",
        "    model.eval()#评估模式\n",
        "    lab=[]\n",
        "    for i in range(8):\n",
        "        if i==2:\n",
        "            continue\n",
        "        infer_imgs = []\n",
        "        infer_imgs.append(load_image('work/' + str(i) + '.png'))\n",
        "        infer_imgs = np.array(infer_imgs)\n",
        "        infer_imgs = fluid.dygraph.to_variable(infer_imgs)\n",
        "        result=model(infer_imgs)\n",
        "        lab.append(np.argmax(result.numpy()))\n",
        "print(lab)\n",
        "display(Image.open('work/车牌.png'))\n",
        "for i in range(len(lab)):\n",
        "    print(LABEL[str(lab[i])],end='')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[32, 7, 42, 60, 42, 46, 13]\n",
            "鲁A686EJ"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=722x170 at 0x7FC279544790>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}